package com.click369.mianshiqingbao.controller;

import com.click369.mianshiqingbao.pojo.ReadLogBean;
import com.click369.mianshiqingbao.pojo.TopicBean;
import com.click369.mianshiqingbao.pojo.entity.PageResult;
import com.click369.mianshiqingbao.pojo.entity.Result;
import com.click369.mianshiqingbao.pojo.entity.TagTypeBean;
import com.click369.mianshiqingbao.pojo.entity.TopicTypeNumBean;
import com.click369.mianshiqingbao.service.ReadLogService;
import com.click369.mianshiqingbao.service.TopicService;
import com.click369.mianshiqingbao.util.SnowflakeIdWorker;
import com.click369.mianshiqingbao.util.StaticFinalFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 题目信息的控制器类
 */
@Controller
@RequestMapping("/topic")
public class TopicController {
    @Autowired
    private TopicService topicService;
    @Autowired
    private ReadLogService readLogService;

    /**
     * 条件分页查询题目信息列表
     * @param topicbean 题目信息对象
     * @param page 页码
     * @param size 每页记录数
     * @return 分页查询信息的封装对象
     */
    @RequestMapping("/search.do")
    @ResponseBody
    public PageResult search(@RequestBody TopicBean topicbean, int page, int size){
        return topicService.findPage(topicbean,page, size);
    }

    /**
     * 新增题目信息
     * @param topicbean 题目信息对象
     * @return 成功或失败的提示信息封装类对象
     */
    @RequestMapping("/add.do")
    @ResponseBody
    public Result add(@RequestBody TopicBean topicbean){
        try {
            topicService.add(topicbean);
            return new Result(true, StaticFinalFile.SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(false,StaticFinalFile.FAILURE);
        }
    }

    /**
     * 根据id查询题目信息对象
     * @param id 题目ID
     * @return 题目信息对象
     */
    @RequestMapping("/findOne.do")
    @ResponseBody
    public TopicBean findOne(Long id){
        return topicService.findOne(id);
    }

    /**
     * 修改题目信息
     * @param topicbean 题目信息对象
     * @return 成功或失败的提示信息封装类对象
     */
    @RequestMapping("/update.do")
    @ResponseBody
    public Result update(@RequestBody TopicBean topicbean){
        try {
            topicService.update(topicbean);
            return new Result(true,StaticFinalFile.SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(false,StaticFinalFile.FAILURE);
        }
    }

    /**
     * 批量删除题目信息
     * @param ids 包含有被删除题目信息的ID数组
     * @return 成功或失败的提示信息封装类对象
     */
    @RequestMapping("/delete.do")
    @ResponseBody
    public Result delete(Long ids[]){
        try {
            topicService.delete(ids);
            return new Result(true,StaticFinalFile.SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(false,StaticFinalFile.FAILURE);
        }
    }

    /**
     * 获取当前用户所选择的一级分类对应的题目列表
     * @param userId 当前登陆的用户ID
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 最近阅读题目列表
     */
    @RequestMapping("/getRecentReadTopic.do")
    @ResponseBody
    public List<TopicBean> getRecentReadTopic(Long userId, Integer classifyId){
        try {
            List<TopicBean> topiclist = new ArrayList<TopicBean>();
            List<ReadLogBean> readloglist = readLogService.getRecentReadLog(userId,classifyId);
            if(readloglist.size()>0){
                for(ReadLogBean readLogBean:readloglist){
                    TopicBean topicBean=topicService.findOne(readLogBean.getTopicId());
                    topiclist.add(topicBean);
                }
                return topiclist;
            }else{
                return null;
            }

        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取所选择的一级分类对应的阅读次数最多的题目列表【10】
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 阅读次数最多的题目列表
     */
    @RequestMapping("/getMostTopic.do")
    @ResponseBody
    public PageResult getMostTopic(Integer classifyId){
        PageResult pageResult = null;
        List<TopicBean> topiclist = null;
        try {
            topiclist = topicService.getMostTopic(classifyId);
            pageResult = new PageResult(topiclist.size(),topiclist);
        }catch (Exception e){
            e.printStackTrace();
            pageResult = new PageResult(0,topiclist);
        }
        return pageResult;
    }
    /**
     * 获取所选择的一级分类对应的最新题目列表【10】
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 最新的题目列表
     */
    @RequestMapping("/getNewTopic.do")
    @ResponseBody
    public PageResult getNewTopic(Integer classifyId){
        PageResult pageResult = null;
        List<TopicBean> topiclist = null;
        try {
            topiclist = topicService.getNewTopic(classifyId);
            pageResult = new PageResult(topiclist.size(),topiclist);
        }catch (Exception e){
            e.printStackTrace();
            pageResult = new PageResult(0,topiclist);
        }
        return pageResult;
    }
    /**
     * 获取所选择的一级分类对应的题型列表
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 题型列表
     */
    @RequestMapping("/getTopicTypeNumList.do")
    @ResponseBody
    public List<TopicTypeNumBean> getTopicTypeNumList(Integer classifyId){
       return topicService.getTopicTypeNumList(classifyId);
    }
    /**
     * 获取所选择的一级分类指定的题型的题目列表
     * @param classifyId 当前用户所选择的一级分类ID
     * @param topicType 指定题型id
     * @return 指定的题型的题目列表
     */
    @RequestMapping("/getTopicBeanList.do")
    @ResponseBody
    public List<TopicBean> getTopicBeanList(Integer classifyId,String topicType){
        return topicService.getTopicBeanList(classifyId,topicType);
    }
    /**
     * 获取当前用户所选择的一级分类的阅读标签列表
     * @param userId 当前用户id
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 当前用户所选择的一级分类的阅读标签列表
     */
    @RequestMapping("/getTagTypeBeanList.do")
    @ResponseBody
    public List<TagTypeBean> getTagTypeBeanList(Long userId,Integer classifyId){
        return topicService.getTagTypeBeanList(userId,classifyId);
    }
    /**
     * 获取当前用户所选择的一级分类得到已读题目列表
     * @param userId 当前用户id
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 已读题目列表
     */
    @RequestMapping("/getReadTopicList.do")
    @ResponseBody
    public List<TopicBean> getReadTopicList(Long userId,Integer classifyId){
        return topicService.getReadTopicList(userId,classifyId);
    }
    /**
     * 获取当前用户所选择的一级分类与对应的阅读状态得到指定阅读状态题目列表
     * @param userId 当前用户id
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 指定阅读状态题目列表
     */
    @RequestMapping("/getReadTagTopicList.do")
    @ResponseBody
    public List<TopicBean> getReadTagTopicList(Long userId,Integer classifyId,String tagFlag){
        return topicService.getReadTagTopicList(userId,classifyId,tagFlag);
    }
    /**
     * 获取当前用户所选择的一级分类得到收藏题目列表
     * @param userId 当前用户id
     * @param classifyId 当前用户所选择的一级分类ID
     * @return 收藏题目列表
     */
    @RequestMapping("/getStoreTopicList.do")
    @ResponseBody
    public List<TopicBean> getStoreTopicList(Long userId,Integer classifyId){
        return topicService.getStoreTopicList(userId,classifyId);
    }
    /**
     * 获取当前用户Id和题目Id查询一个题目对象
     * @param userId 当前用户id
     * @param topicId 题目Id
     * @return 题目对象
     */
    @RequestMapping("/getTopicObject.do")
    @ResponseBody
    public TopicBean getTopicObject(Long userId,Long topicId) {
        try {
            TopicBean topicBean = topicService.getTopicObject(topicId);
            //根据userid和topicid查询阅读记录
            ReadLogBean readLogBean = readLogService.getReadLogBean(userId, topicId);
            if (readLogBean == null) {  //1.1 若之前没看过这道题 需添加一条阅读记录
                ReadLogBean newRead = new ReadLogBean();
                SnowflakeIdWorker snowflakeIdWorker = new SnowflakeIdWorker();
                newRead.setReadId(String.valueOf(snowflakeIdWorker.nextId()));
                newRead.setUserId(userId);
                newRead.setTopicId(topicId);
                newRead.setReadIsStatus(true);
                newRead.setReadTime(new Date());
                newRead.setReadTopicStatus("0");
                newRead.setTopicClassifyOne(topicBean.getTopicClassifyOne());
                newRead.setTopicClassifyTwo(topicBean.getTopicClassifyTwo());
                newRead.setTopicClassifyThree(topicBean.getTopicClassifyThree());
                readLogService.add(newRead);
            } else {                  //1.2 若之前看过这道题 需修改该题目阅读记录
                readLogBean.setReadTime(new Date());
                readLogService.update(readLogBean);
            }
            //2. 修改题目的阅读次数【得到之前的阅读次数，基础上+1】
            topicBean.setTopicFreq(topicBean.getTopicFreq() + 1);
            topicService.update(topicBean);
            return topicBean;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

}
